package com.lzh.others.ComparableInterfacePrac;

import com.lzh.others.ComparableInterfacePrac.Student;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

/**
 * @Description: 示例说明
 * <p>
 * Case-1: 我们的集合中有一个空元素。由于nullsFirst方法返回的比较器，在排序中，null元素将排在第一位。非空元素的顺序将由传递给nullsFirst方法的比较器决定。
 * <p>
 * Case-2: 我们有一个以上的空元素。我们知道，当两个元素都是空的时候，那么它们被认为是相等的。所以，所有的空元素将被排在第一位。非空元素的顺序将由传递给nullsFirst方法的比较器决定。
 * <p>
 * Case-3: 在这种情况下，我们将指定的比较器反转到nullsFirst方法。这将只影响非空元素的顺序。所有的空元素将被排在第一位。
 * <p>
 * Case-4: 在这种情况下，我们将nullsFirst方法返回的比较器反转。现在，所有的空元素将被排在最后。
 * <p>
 * Case-5: 在这种情况下，我们通过比较器来使用元素的自然顺序。对于自然顺序，元素类需要实现Comparable和覆盖compareTo方法。所有的空元素将按顺序排在第一位，非空元素将按其自然顺序排列。
 * <p>
 * Case-6: 在这种情况下，我们将null传递给nullsFirst方法。我们知道，如果指定给nullsFirst的比较器是null，那么返回的比较器会认为所有非null元素都是相等的。所有的空元素将被排在第一位，对非空元素的顺序没有影响。
 * @Author: LiuZiHao
 * @Date: 2022/7/15 10:09
 */
public class NullsFirstDemo {
    public static void main(String[] args) {
        Student s1 = new Student("Ram", 90D, 90D, 90D, 180D, 18);
        Student s2 = new Student(null, 90D, 95D, 85D, 180D, 22);
        Student s3 = new Student("Mohan", 90D, 93D, 87D, 180D, 17);

        System.out.println("-------Case1: One null----------");

        List<Student> list = Arrays.asList(s1, s2, null, s3);
        list.sort(Comparator.nullsFirst(Comparator.comparing(Student::getName)));
        list.forEach(System.out::println);

        System.out.println("--------Case2: More than one null---------");

        list = Arrays.asList(s1, null, s2, null, s3);
        list.sort(Comparator.nullsFirst(Comparator.comparing(Student::getName)));
        list.forEach(System.out::println);

        System.out.println("--------Case3: Reverse specified Comparator to nullsFirst---------");

        list = Arrays.asList(s1, null, s2, null, s3);
        list.sort(Comparator.nullsFirst(Comparator.comparing(Student::getName).reversed()));
        list.forEach(System.out::println);

        System.out.println("--------Case4: Reverse Comparator returned by nullsFirst---------");

        list = Arrays.asList(s1, null, s2, null, s3);
        list.sort(
                Comparator.nullsFirst(Comparator.comparing(Student::getName)).reversed()
        );
        list.forEach(System.out::println);

        System.out.println("--------Case5: Specify natural order Comparator to nullsFirst---------");

        list = Arrays.asList(s1, null, s2, null, s3);
        list.sort(Comparator.nullsFirst(Comparator.naturalOrder()));
        list.forEach(System.out::println);

        System.out.println("--------Case6: Specify null to nullsFirst---------");

        list = Arrays.asList(s1, null, s2, null, s3);
        list.sort(Comparator.nullsFirst(null));
        list.forEach(System.out::println);

        System.out.println("--------Case7: 实现compareTo，自定义排序规则---------");

        list = Arrays.asList(s1, s3, s2, null, null);
        list.sort(Comparator.nullsFirst(Student::compareTo).reversed());
        list.forEach(System.out::println);

        // 1.8 以前的用法
//        Collections.sort(books,new Comparator<Book>() {
//
//            @Override
//            public int compare(Book o1, Book o2) {
//                // TODO Auto-generated method stub
//
//                return o1.getBookPrice() - o2.getBookPrice();
//
//            }
//        });
//
        //2.创建一个比较器
//        package com.my.test.compare;
//
//        import java.util.Comparator;
//
//        public class SimpleCompator implements Comparator<Book> {
//
//            @Override
//            public int compare(Book o1, Book o2) {
//                // TODO Auto-generated method stub
//                return o1.getBookPrice() -o2.getBookPrice();
//            }
//
//        }
//        Collections.sort(books,new SimpleCompator());

        //1.8之后
    }
}
